Automatisation des tests

<!-- ... -->
<dependencies>
    <!-- ... -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.1</version>
        <scope>test</scope>
    </dependency>
    <!-- ... -->
</dependencies>
<build>
    <plugins>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
        </plugin>
        <!-- ... -->
    </plugins>
</build>
<!-- ... -->

import static org.junit.Assert.assertTrue;
import org.junit.Test;

public class BasicTest {
	@Test
	public void simpleTest1() {
		LOGGER.info("--- Running test junit 4 -> 1 ---");
		assertTrue(true);
	}
}

import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;

class BasicTest {
	@Test
	void simpleTest1() {
		LOGGER.info("--- Running test junit 5 -> 1 ---");
		assertTrue(true);
	}
}

<!-- ... -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2/version>
    </dependency>
    <dependency>
        <groupId>org.junit.vintage</groupId>
        <artifactId>junit-vintage-engine</artifactId>
        <version>5.8.1</version>
        <scope>test</scope>
    </dependency>
<!-- ... -->

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BasicTest {

	public static final Logger LOGGER = LoggerFactory.getLogger(BasicTest.class);

	@BeforeAll
	static void initAll() {
		LOGGER.info("--- Running once before first class test junit 5 ---");
	}

	@BeforeEach
	public void init() {
		LOGGER.info("--- Running before test junit 5 ---");
	}

	@Test
	void succeedingTest() {
		LOGGER.info("--- Running test junit 5 -> 1 ---");
		assertTrue(true);
	}

	@Test
	@Disabled("Test ne marche plus mais il faut livrer")
	void skipFailingTest() {
		LOGGER.info("--- Running test junit 5 -> 2 ---");
		fail("Failing test");
	}

	@AfterEach
	void tearDown() {
		LOGGER.info("--- Running after test junit 5 ---");
	}

	@AfterAll
	static void tearDownAll() {
		LOGGER.info("--- Running once after last class test junit 5 ---");
	}
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.RepetitionInfo;
import org.junit.jupiter.api.TestInfo;

class RepeatedTestsDemo {

    @BeforeEach
    void beforeEach(TestInfo testInfo, RepetitionInfo repetitionInfo) {
        int currentRepetition = repetitionInfo.getCurrentRepetition();
        int totalRepetitions = repetitionInfo.getTotalRepetitions();
        String methodName = testInfo.getTestMethod().get().getName();
        logger.info(String.format("About to execute repetition %d of %d for %s", //
            currentRepetition, totalRepetitions, methodName));
    }

    @RepeatedTest(10)
    void repeatedTest() {
        // ...
    }

    @RepeatedTest(5)
    void repeatedTestWithRepetitionInfo(RepetitionInfo repetitionInfo) {
        assertEquals(5, repetitionInfo.getTotalRepetitions());
    }
}
/*
├─ RepeatedTestsDemo ✔
│  ├─ repeatedTest() ✔
│  │  ├─ repetition 1 of 10 ✔
│  │  ├─ repetition 2 of 10 ✔
│  │  ├─ repetition 3 of 10 ✔
│  │  ├─ repetition 4 of 10 ✔
│  │  ├─ repetition 5 of 10 ✔
│  │  ├─ repetition 6 of 10 ✔
│  │  ├─ repetition 7 of 10 ✔
│  │  ├─ repetition 8 of 10 ✔
│  │  ├─ repetition 9 of 10 ✔
│  │  └─ repetition 10 of 10 ✔
│  ├─ repeatedTestWithRepetitionInfo(RepetitionInfo) ✔
│  │  ├─ repetition 1 of 5 ✔
│  │  ├─ repetition 2 of 5 ✔
│  │  ├─ repetition 3 of 5 ✔
│  │  ├─ repetition 4 of 5 ✔
│  │  └─ repetition 5 of 5 ✔
*/

class ParameterizedTestDemo {

    @ParameterizedTest
    @NullSource
    @EmptySource
    @ValueSource(strings = {"String 1", "String 2", "\n"})
    void shouldExecuteForStringList(String input) {
        /* input = [ null, "", "String 1", "String 2", "\n"] */
    }

}

@ValueSource(ints = { 1, 2, 3 })

    @ParameterizedTest
    @EnumSource(value = Month.class, names = {"APRIL", "JUNE", "SEPTEMBER", "NOVEMBER"})
    void testEnumParam(Month param) {
        LOGGER.info("Exécution test enum param, valeur : " + param);
        assertNotNull(param);
    }

    @ParameterizedTest
    @MethodSource("stringProvider")
    void testWithExplicitLocalMethodSource(String argument) {
        assertNotNull(argument);
    }

    static Stream<String> stringProvider() {
        return Stream.of("apple", "banana");
    }

    static Stream<Arguments> stringIntAndListProvider() {
        return Stream.of(
            arguments("apple", 1, Arrays.asList("a", "b")),
            arguments("lemon", 2, Arrays.asList("x", "y"))
        );
    }

    @ParameterizedTest
    @CsvSource({
        "apple, 1",
        "banana, 2",
        "lemon, 3",
        "strawberry, 4"
    })
    void testWithCsvSource(String fruit, int rank) {
        assertNotNull(fruit);
        assertNotEquals(0, rank);
    }

@ParameterizedTest
@CsvFileSource(resources = "/two-column.csv", numLinesToSkip = 1)
void testWithCsvFileSourceFromClasspath(String country, int reference) {
    assertNotNull(country);
    assertNotEquals(0, reference);
}

@ParameterizedTest
@CsvFileSource(files = "src/test/resources/two-column.csv", numLinesToSkip = 1)
void testWithCsvFileSourceFromFile(String country, int reference) {
    assertNotNull(country);
    assertNotEquals(0, reference);
}

@Rule
public TemporaryFolder tmpFolder = new TemporaryFolder();

/* Erreur d'assertion si le temporary folder ne peut être supprimé */
public TemporaryFolder folder = TemporaryFolder.builder().assureDeletion().build();

@ClassRule
public static TemporaryFolder globalFolder = new TemporaryFolder();

/* Répertoire tmp de classe */
@TempDir
static Path sharedTempDir;

/* Répertoire tmp de méthode test */
@TempDir
File tempDir;

@ExtendWith(MockitoExtension.class)
@ExtendWith({ a.class, b.class })
public class ExtensionTest {

    @Test
    @ExtendWith(c.class)
    void should_use_extensions() {
        ...
    }
}

public class MyCustomParameterResolver implements ParameterResolver {

    @Override
    public boolean supportsParameter(ParameterContext parameterContext,
      ExtensionContext extensionContext) throws ParameterResolutionException {
        // Retourne true si le type de l'objet paramètre est correct
        ...
        return parameterContext.getParameter().getType() == MyCustomParameterType.class;
    }

    @Override
    public Object resolveParameter(ParameterContext parameterContext,
      ExtensionContext extensionContext) throws ParameterResolutionException {
        //Retourne l'instance d'un objet à utiliser en paramètre
        MyCustomParameterType customParam = new MyCustomParameterType();
        ...
        return customParam;
    }
}

@ExtendWith(MyCustomParameterResolver.class)
public class CustonParameterResolverTest {

    private MyCustomParameterType customParamGlobal;

    public CustonParameterResolverTest(MyCustonParameterType customParam) {
        this.customParamGlobal = customParam;
    }

    @Test
    void test(MyCustonParameterType customParam) {
        ...
    }

assertAll("Should check user admin identity",
    () -> assertEquals("admin", user.getLastName()),
    () -> assertEquals("admin", user.getFirstName()),
    () -> assertTrue(user.isAdmin())
);

assertAll("person",
    () -> {
        String firstName = person.getFirstName();
        assertNotNull(firstName);
        // Executed only if the previous assertion is valid.
        assertAll("first name",
            () -> assertTrue(firstName.startsWith("J")),
            () -> assertTrue(firstName.endsWith("e"))
        );
    },
    () -> {
        // Grouped assertion, so processed independently
        // of results of first name assertions.
        String lastName = person.getLastName();
        assertNotNull(lastName);
        // Executed only if the previous assertion is valid.
        assertAll("last name",
            () -> assertTrue(lastName.startsWith("D")),
            () -> assertTrue(lastName.endsWith("e"))
        );
    }
);